switch!(match x {
        v if v == 1 => {
            r += 10;
        }
        v if v == 2 => {
            r += 20;
            break;
        }
        _ => {
            r = -1_i32;
            break;
        }
    });

    {                                                                                                                                                                                         
        let mut __s: u32 = 0;                                                                                                                                                                 
                                                                                                                                                                                              
        #[allow(unreachable_code, unused_labels)]                      
        '__sm: loop {                
            match __s {
                // First arm is the dispatch arm. It decides which is the first state: [1u32, ...]
                0u32 => {

                    #[allow(unreachable_code)]
                    {
                        {

                            #[allow(unreachable_patterns)]
                            match x {
                                v if v == 1 => { __s = 1u32; continue '__sm; }
                                v if v == 2 => { __s = 2u32; continue '__sm; }
                                _ => { __s = 3u32; continue '__sm; }
                                _ => break '__sm,
                            }
                        };
                        __s = 1u32;
                        continue '__sm;
                    }
                }
                1u32 => {
                    // First real arm, it contains the body of the original arm + fallthrough to the following state, i.e. 2u32
                    #[allow(unreachable_code)]
                    { { r += 10; }; __s = 2u32; continue '__sm; }
                }
                2u32 => {
                    // Second real arm, inside the body there is a break statement that stops the fallthrough
                    #[allow(unreachable_code)]
                    { { r += 20; break '__sm; }; __s = 3u32; continue '__sm; }
                }
                3u32 => {
                    // Default arm from the original match, the last arm breaks the state machine instea of continuing
                    #[allow(unreachable_code)]
                    { { r = -1_i32; break '__sm; }; break '__sm; }
                }
                // This is here only for match exhaustiveness, it's never used
                _ => break '__sm,
            }
        }
    };